package com.example.administrator.exkotlin.base

import android.util.Log
import kotlin.math.max

class BaseKotlin {
    private val TAG = "BaseKotlin"
    fun add(add1: Int = 0, add2: Int = 0): Int {
        return add1 + add2
    }

    fun largerNumberEx1(num1: Int, num2: Int): Int {
        return max(num1, num2)
    }

    fun largerNumberEx2(num1: Int, num2: Int): Int {
        var result = 0
        if (num1 > num2) {
            result = num1
        } else {
            result = num2
        }
        return result
    }

    fun largerNumberEx3(num1: Int, num2: Int) = if (num1 > num2) {
        num1
    } else {
        num2
    }

    fun largerNumberEx4(num1: Int, num2: Int) = if (num1 > num2) num1 else num2

    fun getScore1(name: String) = if (name == "Tom") {
        70
    } else if (name == "jerry") {
        80
    } else {
        0
    }

    fun getScore2(name: String) = when (name) {
        "Tom" -> {

        }
        "jerry" -> 80

        else -> 0
    }

    fun checkNumber(num: Number) {
        when (num) {
            is Int -> {
                Log.d(TAG, "num is Int")
            }
            is Double -> {
                Log.d(TAG, "num is Double")
            }
            else -> {
                Log.d(TAG, "num is not supprot")
            }
        }
    }

    fun getScore20(name: String) = when {
        name == "Tom" -> {
            100
        }
        name == "Jerry" -> 80
        name == "Bob" -> 70
        name.startsWith("J") -> 60
        else -> 0
    }

    fun forIn(range1: Int, range2: Int) {
        for (a in range1..range2 step 1) {
            println(a)
        }
    }

    fun forIn2(range1: Int, range2: Int) {
        for (a in range1 until range2 step 2) {
            println(a)
        }
    }

    fun forIn3(range1: Int, range2: Int) {
        for (a in range1 downTo range2 step 2) {
            println(a)
        }
    }


    /**
     * 静态方法：不通过实例化对象，即可使用的方法
     *
     * kotlin中的类似静态调用实现
     * 1.object修饰类，形成单例类，直接调用其内部方法
     * 2.companion object中定义方法，会自动创建伴生类，调用上类似于静态方法，但不是。
     * 3. companion object中的方法再使用@JvmStatic注解，是真正的静态方法
     * 4.顶层方法 xx.kt文件中的方法，在java中调用的时候其方法被编译为静态方法
     *
     * 需要通过注解和顶层方法才能真正的创建静态类
     * */
    companion object {

        //定义常量,在 companion object ，单例类，顶层类中使用 const关键字申明的变量为常量
        const val TAG = "BaseKotlin"

        //companion object中的方法只是在类的内部创建一个伴生类，方法定义在伴生类中，起到类似于静态方法的作用
        //在java中并不能直接使用该方法，因为不是真的静态方法
        fun static_kotin() {
            println("kotlin中的伴生类模仿静态方法")
        }

        //只能在companion object中使用 @JvmStatic 注解
        @JvmStatic
        fun static_koltin_2() {
            println("koltin通过注解编译成正在静态方法")
        }

    }

}